home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume4 / rolodex / part3 < prev    next >
Encoding:
Internet Message Format  |  1986-11-30  |  60.8 KB
  1. From: ihnp4!think!massar (JP Massar)
  2. Subject: rolodex database program -- part 3 of 3
  3. Newsgroups: mod.sources
  4. Approved: jpn@panda.UUCP
  5.  
  6. Mod.sources:  Volume 4, Issue 29
  7. Submitted by: ihnp4!think!massar (JP Massar)
  8.  
  9. #! /bin/sh
  10. # This is a shell archive, meaning:
  11. # 1. Remove everything above the #! /bin/sh line.
  12. # 2. Save the resulting text in a file.
  13. # 3. Execute the file with /bin/sh (not csh) to create the files:
  14. #    toolsdir
  15. # This archive created: Thu Mar 13 18:29:56 1986
  16. export PATH; PATH=/bin:$PATH
  17. if test ! -d 'toolsdir'
  18. then
  19.     echo shar: creating directory "'toolsdir'"
  20.     mkdir 'toolsdir'
  21. fi
  22. echo shar: extracting "'toolsdir/Makefile'" '(143 characters)'
  23. if test -f 'toolsdir/Makefile'
  24. then
  25.     echo shar: will not over-write existing file "'toolsdir/Makefile'"
  26. else
  27. cat << \SHAR_EOF > 'toolsdir/Makefile'
  28. CC = cc
  29. CFLAGS = -DBSD42 -O
  30. DBGFLAG = 
  31. SOURCES = mem.c ctools.c args.c menu.c
  32. OBJECTS = mem.o ctools.o args.o menu.o
  33. LIBS =
  34.  
  35. tools: $(OBJECTS)
  36. SHAR_EOF
  37. if test 143 -ne "`wc -c < 'toolsdir/Makefile'`"
  38. then
  39.     echo shar: error transmitting "'toolsdir/Makefile'" '(should have been 143 characters)'
  40. fi
  41. fi
  42. echo shar: extracting "'toolsdir/args.c'" '(8623 characters)'
  43. if test -f 'toolsdir/args.c'
  44. then
  45.     echo shar: will not over-write existing file "'toolsdir/args.c'"
  46. else
  47. cat << \SHAR_EOF > 'toolsdir/args.c'
  48. #include <stdio.h>
  49. #include <ctype.h>
  50. #include "basics.h"
  51. #include "args.h"        
  52. #include "sys5.h"
  53.  
  54. /***************************************************************************/
  55. /***************************************************************************/
  56.  
  57.            /*****     COMMAND LINE ARGUMENT PARSER    *****/
  58.  
  59. /***************************************************************************/
  60. /***************************************************************************/
  61.  
  62. /* Author: JP Massar */
  63.  
  64. /* parses command line arguments in argv under the following rules: */
  65. /* any argument not beginning with '-' is treated as a unit. */
  66. /* any argument beginning with a '-' must have the remaining characters */
  67. /* be in the set {a-zA-Z}.  Each character is considered a separate option. */
  68. /* (Thus -abc is equivalent to -a -b -c).  Non-dashed arguments are */
  69. /* associated with the option that precedes them, e.g, 'cat -a foo -b bar' */
  70. /* has foo associated with 'a' and bar associated with 'b'.  A non-dashed */
  71. /* argument preceding any option is not associated with any option. */
  72. /* users can specify whether duplicate options are errors. */
  73.  
  74. /* Non-dashed arguments are henceforth referred to as arguments, and */
  75. /* dashed arguments are henceforth referred to as options. */
  76. /* Arguments are ordered from left to right. */
  77.  
  78. /* The following routines are available to users: */
  79.  
  80. /* get_args()           called to parse argv.  Detects syntactic errors */
  81. /* any_option_present() are any options present in the command line? */
  82. /* option_present()     is an option present? */
  83. /* option_arg()         returns an argument associated with an option */
  84. /* non_option_arg()     returns an argument not associated with any option */
  85. /* non_dash_arg()       returns an argument */
  86. /* n_option_args()      returns number of args associated with an option */
  87. /* n_non_option_args()  rtns number of args not associated with any option */
  88. /* n_non_dash_args()    returns number of arguments. */
  89. /* check_option_args()  checks bounds on number of args assoc with an option */
  90. /* legal_options()      checks that options provided are a subset of a-zA-Z */
  91. /* set_option()         turns on option */
  92. /* error_message()      prints out an illegal syntax error message to stderr */
  93.  
  94.  
  95. int option_to_index (achar) char achar;
  96. {
  97.   if (isupper(achar)) return(achar - 'A');
  98.   if (islower(achar)) return(achar - 'a' + 26);
  99.   return(NO_OPTION);
  100. }
  101.  
  102. char index_to_option (index) int index;
  103. {        
  104.   if (index < 26) return('A' + index);
  105.   return('a' + index - 26);
  106. }  
  107.  
  108.  
  109. /* the command line arguments are parsed into Cmd when get_args returns */
  110. /* successfully */
  111.  
  112. static Ptr_Cmd_Line Cmd = NIL;
  113.  
  114. int get_args (argc, argv, dup_error, print_msg)
  115.         
  116.   /* Returns one of NO_ARGS, ARG_ERROR, or ARGS_PRESENT */
  117.  
  118.   int argc;
  119.   char **argv;
  120.   Bool print_msg, dup_error;
  121.  
  122. {
  123.   int i,j,dash_index;
  124.   Ptr_Cmd_Arg arg,last = NIL;
  125.   char echar, *optr;
  126.  
  127.   Cmd = (Ptr_Cmd_Line) malloc(sizeof(Cmd_Line));
  128.   Cmd -> non_dash_arg_list = NIL;
  129.   for (j = 0; j < MAX_OPTIONS; j++) (Cmd -> dash_options)[j] = F;
  130.  
  131.   if (argc == 1) return(NO_ARGS);
  132.  
  133.   i = 0;
  134.   dash_index = NO_OPTION;
  135.   
  136.   while (++i < argc) {
  137.         
  138.         /* parse arguments (i.e., anything not beginning with '-' */
  139.         
  140.         if (argv[i][0] != '-') {
  141.                 arg = (Ptr_Cmd_Arg) malloc(sizeof(Cmd_Arg));
  142.                 arg -> option = argv[i];
  143.                 arg -> option_index = dash_index;
  144.                 arg -> next = NIL;
  145.                 if (last == NIL) {
  146.                         Cmd -> non_dash_arg_list = arg;
  147.                         last = arg;
  148.                 }                
  149.                 else {
  150.                         last -> next = arg;
  151.                         last = arg;
  152.                 }
  153.                 continue;
  154.         }
  155.  
  156.         /* parse options. '-' by itself is illegal syntax */
  157.         
  158.         if (strlen(argv[i]) < 2) {
  159.                 echar = '-';
  160.                 goto parse_error;
  161.         }        
  162.         optr = argv[i];
  163.         optr++;
  164.         while (*optr != '\0') {
  165.                 if (NO_OPTION == (dash_index = option_to_index(*optr))) {
  166.                         echar = *optr;
  167.                         goto parse_error;
  168.                 };
  169.                 if ((Cmd -> dash_options)[dash_index] && dup_error) {
  170.                         echar = *optr;
  171.                         goto duplicate_error;
  172.                 }
  173.                 (Cmd -> dash_options)[dash_index] = T;
  174.                 optr++;
  175.         }
  176.  
  177.   }
  178.  
  179.   return(ARGS_PRESENT);
  180.  
  181.   parse_error :
  182.  
  183.   if (print_msg) fprintf(stderr,"illegal option: %c\n",echar);
  184.   return(ARG_ERROR);
  185.  
  186.   duplicate_error:
  187.  
  188.   if (print_msg) fprintf(stderr,"duplicate option: %c\n",echar);
  189.   return(ARG_ERROR);
  190.  
  191. }  
  192.  
  193.  
  194. Bool option_present (achar) char achar;
  195. {        
  196.   return((Cmd -> dash_options)[option_to_index(achar)]);
  197. }
  198.  
  199.  
  200. Bool any_option_present ()
  201. {
  202.   int j;
  203.   for (j = 0; j < MAX_OPTIONS; j++) {
  204.       if ((Cmd -> dash_options)[j]) return(T);
  205.   }      
  206.   return(F);
  207. }  
  208.  
  209.   
  210. char * get_option_arg (i,n) int i; int n;
  211.  
  212.   /* get the nth option associated with the option whose index is 'i' */
  213.         
  214. {
  215.   int count;
  216.   Ptr_Cmd_Arg args;        
  217.   args = Cmd -> non_dash_arg_list;  
  218.   count = 0;
  219.   while (args != NIL) {
  220.         if (i == args -> option_index && ++count == n) {
  221.                 return(args -> option);
  222.         }
  223.         args = args -> next;
  224.   }
  225.   return(NIL);
  226. }  
  227.  
  228.  
  229. char * option_arg (achar,n) char achar; int n;
  230. {
  231.   return(get_option_arg(option_to_index(achar),n));
  232. }
  233.  
  234.  
  235. char * non_option_arg (n) int n;
  236. {
  237.   return(get_option_arg(NO_OPTION,n));
  238. }  
  239.  
  240.  
  241. char * non_dash_arg (n) int n;
  242.  
  243. {
  244.   int count = 0;
  245.   Ptr_Cmd_Arg arg;
  246.   arg = Cmd -> non_dash_arg_list;
  247.   while (arg != NIL) {
  248.         if (++count == n) return(arg -> option);
  249.         arg = arg -> next;
  250.   }
  251.   return(NIL);
  252. }
  253.  
  254. print_args ()
  255.  
  256.   /* debugging routine which prints out the Cmd structure in readable form */
  257.  
  258. {
  259.   int j,i,n;
  260.   char *option,ochar;
  261.  
  262.   if (Cmd == NIL) {
  263.         printf("\n\nNo arguments\n\n");
  264.         return;
  265.   }        
  266.   
  267.   printf("\n\narguments not associated with options: ");
  268.   n = 1;
  269.   while (T) {
  270.         if (NIL == (option = non_option_arg(n++))) break;
  271.         printf("%s ",option);
  272.   }
  273.   printf("\n");
  274.  
  275.   printf("\n\noptions and their arguments:\n\n");
  276.   for (j = 0; j < MAX_OPTIONS; j++) {
  277.       ochar = index_to_option(j);
  278.       if (option_present(ochar)) {
  279.          printf("%c : \t",ochar);
  280.          i = 1;
  281.          while (T) {
  282.            if (NIL == (option = option_arg(ochar,i++))) break;
  283.            printf("%s ",option);
  284.          }
  285.          printf("     \t(# is %d)",n_option_args(ochar));
  286.          printf("\n");
  287.       }
  288.   }
  289.  
  290.   printf("\nnumber of non-dashed args is: %d\n",n_non_dash_args());
  291.   printf("number of non-option args is  : %d\n",n_non_option_args());
  292.   
  293. }
  294.  
  295.  
  296. #define ALL -1
  297. #define NON_OPTION -2
  298.  
  299. int arg_counter (type) int type;
  300.  
  301.   /* general routine which counts arguments */
  302.   /* if type isn't ALL or NON_OPTION then type is an index of an option */
  303.  
  304. {
  305.   int index,count;
  306.   Ptr_Cmd_Arg arg;
  307.   arg = Cmd -> non_dash_arg_list;        
  308.   count = 0;
  309.   index = (type == NON_OPTION) ? NO_OPTION : type;
  310.   while (arg != NIL) {
  311.         if (type == ALL) {
  312.                 count++;
  313.         }
  314.         else if (arg -> option_index == index) count++;
  315.         arg = arg -> next;
  316.   }
  317.   return(count);
  318. }
  319.  
  320. int n_option_args (achar) char achar;
  321. {        
  322.   return(arg_counter(option_to_index(achar)));
  323. }
  324.  
  325. int n_non_option_args ()
  326. {
  327.   return(arg_counter(NON_OPTION));
  328. }
  329.  
  330. int n_non_dash_args ()
  331. {
  332.   return(arg_counter(ALL));
  333. }
  334.  
  335.  
  336. set_option (achar) char achar;
  337. {
  338.   (Cmd -> dash_options)[option_to_index(achar)] = T;
  339. }
  340.  
  341.  
  342. error_message (progname, argv, i, usage)
  343.         char *progname; char ** argv; int i; char *usage;
  344. {
  345.   fprintf(stderr,"\nillegal argument to %s : %s\n",progname,argv[i]);
  346.   if (usage) fprintf(stderr,"%s\n",usage);
  347. }
  348.  
  349.  
  350. Bool
  351. check_option_args (achar,themin,themax) char achar; int themin,themax;
  352. {
  353.   int n;
  354.   if (themin > themax) return(T);
  355.   n = n_option_args(achar);
  356.   return ((Bool) (n >= themin && n <= themax));
  357. }
  358.  
  359.  
  360. char legal_options (legalstring) char *legalstring;
  361.  
  362.   /* are all the options the user specified characters in legalstring? */
  363.   /* returns ALL_LEGAL if so, otherwise the first option not in the string */
  364.  
  365. {
  366.   int j;
  367.   char option, *s;
  368.   for (j = 0; j < MAX_OPTIONS; j++) {
  369.       if ((Cmd -> dash_options)[j]) {
  370.          option = index_to_option(j);
  371.          s = legalstring;
  372.          while (T) {
  373.                if (*s == '\0') return(option);
  374.                if (*s == option) break;
  375.                s++;
  376.          }
  377.       }
  378.   }
  379.   return(ALL_LEGAL);
  380. }
  381. SHAR_EOF
  382. if test 8623 -ne "`wc -c < 'toolsdir/args.c'`"
  383. then
  384.     echo shar: error transmitting "'toolsdir/args.c'" '(should have been 8623 characters)'
  385. fi
  386. fi
  387. echo shar: extracting "'toolsdir/args.h'" '(2401 characters)'
  388. if test -f 'toolsdir/args.h'
  389. then
  390.     echo shar: will not over-write existing file "'toolsdir/args.h'"
  391. else
  392. cat << \SHAR_EOF > 'toolsdir/args.h'
  393. /* You must include "basics.h" to use this */
  394.  
  395. /* To use this package, first call get_args, then call the various other */
  396. /* routines to see which options were given, etc. */
  397.  
  398. #define NIL 0                          /* null pointer  */
  399.  
  400. #define ARG_ERROR -1
  401. #define NO_ARGS 0
  402. #define ARGS_PRESENT 1
  403.  
  404. #define MAX_OPTIONS 52                 /* a-z A-Z */
  405. #define NO_OPTION -1
  406.  
  407. /* an argument and the option it is associated with */
  408.  
  409. typedef struct argument {
  410.         char *option;
  411.         int option_index;
  412.         struct argument *next;
  413. } Cmd_Arg, *Ptr_Cmd_Arg;
  414.  
  415. /* all the arguments (in a list) and a toggle for every possible option */
  416.  
  417. typedef struct {
  418.         Ptr_Cmd_Arg non_dash_arg_list; 
  419.         int dash_options[MAX_OPTIONS];
  420. } Cmd_Line, *Ptr_Cmd_Line;
  421.  
  422. /*--------------------------------------------------------------------------*/
  423.         
  424. extern char *malloc();
  425.  
  426. extern int get_args();
  427.  
  428.         /* int argc; char **argv; Bool dup_error; Bool print_msg; */
  429.         /* returns one of ARG_ERROR, NO_ARGS, or ARGS_PRESENT */
  430.         /* if dup_error, then having two identical options on the command */
  431.         /* line will cause an error.  If print_msg, then  any error that */
  432.         /* is noticed is printed out to stderr.  If !dup_error then */
  433.         /* 'foo -a 3 4 -b -a 5' is equivalent to 'foo -a 3 4 5 -b' */
  434.         
  435.         
  436. extern Bool any_option_present();
  437.  
  438.         /* no arguments */
  439.  
  440. extern Bool option_present();
  441.  
  442.         /* char achar; */
  443.  
  444. extern char * option_arg();
  445.  
  446.         /* char achar; int n; */
  447.  
  448. extern char * non_option_arg();
  449.  
  450.         /* int n; */
  451.  
  452. extern int n_option_args();
  453.  
  454.         /* char achar; */
  455.  
  456. extern int n_non_option_args();
  457.  
  458.         /* no arguments */
  459.  
  460. extern int n_non_dash_args();
  461.  
  462.         /* no arguments */
  463.  
  464. extern Bool check_option_args();        
  465.  
  466.         /* char achar; int min; int max; */
  467.  
  468. #define ALL_LEGAL 0
  469.  
  470. extern char legal_options();
  471.  
  472.         /* char *legaloptions; */
  473.         /* legaloptions should be a string of characters all in the range */
  474.         /* a-zA-Z.   Returns ALL_LEGAL if every option parsed in included */
  475.         /* in the legaloptions string, otherwise returns the first option */
  476.         /* character not in the string. */
  477.  
  478. extern set_option();
  479.  
  480.         /* char achar */
  481.  
  482. extern error_message();
  483.  
  484.         /* char *progname; char **argv; int index; char *usage; */
  485.  
  486. extern print_args();
  487.  
  488.         /* debugging routine */
  489. SHAR_EOF
  490. if test 2401 -ne "`wc -c < 'toolsdir/args.h'`"
  491. then
  492.     echo shar: error transmitting "'toolsdir/args.h'" '(should have been 2401 characters)'
  493. fi
  494. fi
  495. echo shar: extracting "'toolsdir/basics.h'" '(186 characters)'
  496. if test -f 'toolsdir/basics.h'
  497. then
  498.     echo shar: will not over-write existing file "'toolsdir/basics.h'"
  499. else
  500. cat << \SHAR_EOF > 'toolsdir/basics.h'
  501. #define T 1
  502. #define F 0
  503.  
  504. #define True 1
  505. #define False 0
  506.  
  507. #define SUCCESS 1
  508. #define FAILURE 0
  509. #define ERROR -1
  510.  
  511. #define Bool int
  512.  
  513. #define MAXINT 2147483647
  514. #define MAXINTSTR "2147483647"
  515. SHAR_EOF
  516. if test 186 -ne "`wc -c < 'toolsdir/basics.h'`"
  517. then
  518.     echo shar: error transmitting "'toolsdir/basics.h'" '(should have been 186 characters)'
  519. fi
  520. fi
  521. echo shar: extracting "'toolsdir/ctools.c'" '(20370 characters)'
  522. if test -f 'toolsdir/ctools.c'
  523. then
  524.     echo shar: will not over-write existing file "'toolsdir/ctools.c'"
  525. else
  526. cat << \SHAR_EOF > 'toolsdir/ctools.c'
  527. /* -*- Mode: C; Package: (CTOOLS C) -*- */
  528.  
  529. #include <ctype.h>
  530. #include <stdio.h>
  531.  
  532. #ifdef BSD42
  533. #include <strings.h>
  534. #endif
  535.  
  536. #include "ctools.h"
  537.  
  538. /* miscellaneous fairly primitive routines that deal with characters, */
  539. /* strings, memory, simple input and pathnames. */
  540.  
  541.  
  542. /* Author:  JP Massar */
  543. /* Thinking Machines Corporation */
  544.  
  545. /* Included routines:
  546.  
  547.    emalloc
  548.    anewstr
  549.    
  550.    copy
  551.    fill
  552.    
  553.    to_upper_if_lower
  554.    to_lower_if_upper
  555.    
  556.    buffconcat
  557.    nbuffconcat
  558.    
  559.    slcompare
  560.    slge_compare
  561.    nocase_compare
  562.    
  563.    strfind
  564.    strncfind
  565.    strsearch
  566.    strncsearch
  567.    
  568.    yes_or_no_check
  569.    
  570.    remove_excess_blanks
  571.    ip_string_trim
  572.    string_trim
  573.    string_upcase
  574.    string_downcase
  575.    
  576.    all_digits
  577.    all_whitespace
  578.    all_uppercase
  579.    all_lowercase
  580.    all_alphabetic
  581.    all_alphanumeric
  582.    all_ascii
  583.    
  584.    str_to_pos_int
  585.    
  586.    sreverse
  587.    ip_sreverse
  588.         
  589.    temp_path
  590.    perm_path
  591.    make_path_numeric_extension
  592.    make_path
  593.    just_filename
  594.    
  595.    read_yes_or_no
  596.    getline
  597.    getlines
  598.    ngetlines
  599.    getfile
  600.    ngetfile
  601.    read_file_into_buffer
  602.    efopen
  603.  
  604.    check_int
  605.    check_string
  606.    
  607. */
  608.    
  609.  
  610. extern char *malloc();
  611.  
  612.  
  613. char *emalloc (space) int space;
  614.  
  615. /* allocate 'space' bytes, die if we have run out of memory. */
  616.  
  617. {
  618.   char *rval;        
  619.   if (space < 0) {
  620.      fprintf(stderr,"Fatal error: argument to emalloc < 0\n");
  621.      exit(-1);
  622.   }
  623.   if (0 == (rval = malloc((unsigned) space))) {
  624.      fprintf(stderr,"Fatal error:  No more memory\n");
  625.      exit(-1);
  626.   }
  627.   return(rval);
  628. }  
  629.  
  630.  
  631. char *anewstr (astring) char *astring;
  632.  
  633. /* allocate space for and then copy a string.  Returns pointer to */
  634. /* new string. */
  635.  
  636. {        
  637.   char *newstr;
  638.   newstr = emalloc(strlen(astring)+1);
  639.   strcpy(newstr,astring);
  640.   return(newstr);
  641. }
  642.  
  643.  
  644. copy (dest,src,n)
  645.  
  646.   /* copy n bytes */
  647.  
  648.   register char *dest,*src;
  649.   register int n;
  650.  
  651.   { register int j = 0;
  652.     while (j++ < n) *dest++ = *src++; 
  653.   }
  654.  
  655.  
  656. fill (addr,ch,n)
  657.  
  658.   /* fill n sequential bytes with 'ch' */
  659.  
  660.   register char *addr;
  661.   register char ch;
  662.   register int n;
  663.   
  664.   { register int j = 0;
  665.     while (j++ < n) *addr++ = ch;
  666.   }
  667.  
  668.  
  669. to_upper_if_lower (ch)
  670.  
  671.   char ch;
  672.  
  673.   { return(islower(ch) ? toupper(ch) : ch); }
  674.  
  675.  
  676. to_lower_if_upper (ch)
  677.  
  678.   char ch;
  679.  
  680.   { return(isupper(ch) ? tolower(ch) : ch); }
  681.  
  682.  
  683. buffconcat (buffer,s1,s2) 
  684.  
  685.   /* concatenate two null terminated strings into a buffer. */
  686.  
  687.   char *buffer, *s1, *s2;
  688.   
  689.   { while (*s1 != '\0') *buffer++ = *s1++;
  690.     while (*s2 != '\0') *buffer++ = *s2++;
  691.     *buffer = '\0';
  692.   }
  693.  
  694.  
  695. nbuffconcat (buffer,n,s1,s2,s3,s4,s5,s6)
  696.  
  697.   /* concatenates up to 6 strings into a buffer.  Returns -1 if n */
  698.   /* is not reasonable, otherwise returns 0. */
  699.  
  700.   char *buffer;
  701.   int n;
  702.   char *s1,*s2,*s3,*s4,*s5,*s6;
  703.  
  704. {
  705.   register char *b;
  706.   register char *s;
  707.   int i;
  708.   b = buffer;
  709.   if (n < 1 || n > 6) return(-1);
  710.   for (i = 1; i <= 6; i++) {
  711.       if (i > n) break;
  712.       switch (i) {
  713.         case 1 : s = s1; break;
  714.         case 2 : s = s2; break;
  715.         case 3 : s = s3; break;
  716.         case 4 : s = s4; break;
  717.         case 5 : s = s5; break;
  718.         case 6 : s = s6; break;
  719.       }
  720.       while (*s != '\0') *b++ = *s++;
  721.   }
  722.   *b = '\0';
  723.   return(0);
  724. }
  725.  
  726.  
  727. slcompare (s1,l1,s2,l2)
  728.  
  729.   /* compare strings with possible nulls in them given their lengths */
  730.   /* only returns EQUAL (0) or NOT EQUAL (-1) */
  731.  
  732.   char *s1;
  733.   int l1;
  734.   char *s2;
  735.   int l2;
  736.  
  737.   { int j;
  738.     if (l1 != l2) return(-1);
  739.     j = 0;
  740.     while (j++ < l1) 
  741.       if (*s1++ != *s2++) return(-1);
  742.     return(0);
  743.   }
  744.  
  745.   
  746. slge_compare (s1,l1,s2,l2)
  747.  
  748.   /* returns -1 if s1 < s2; 1 if s2 < s1; 0 if s1 = s2 */
  749.   /* ignores nulls in the strings */
  750.  
  751.   char *s1;
  752.   int l1;
  753.   char *s2;
  754.   int l2;
  755.  
  756.   { int j,len;
  757.     j = 0;
  758.     len = l2 > l1 ? l1 : l2;
  759.     while (j++ < len) {
  760.       if (*s1 != *s2) 
  761.          return((*s1 < *s2) ? -1 : 1);
  762.       s1++;   
  763.       s2++;
  764.     }  
  765.     return((l2 == l1) ? 0 : ((l1 < l2) ? -1 : 1));
  766.   }
  767.  
  768. nocase_compare (s1,l1,s2,l2)
  769.  
  770.   /* treats nulls as normal characters.  Returns same as slge_compare */
  771.  
  772.   char *s1;
  773.   int l1;
  774.   char *s2;
  775.   int l2;
  776.  
  777.   { int j,len,ch1,ch2;
  778.     j = 0;
  779.     len = l2 > l1 ? l1 : l2;
  780.     while (j++ < len) {
  781.       ch1 = to_upper_if_lower(*s1++);
  782.       ch2 = to_upper_if_lower(*s2++);
  783.       if (ch1 != ch2) {
  784.          return((ch1 < ch2) ? -1 : 1);
  785.       }
  786.     }  
  787.     return((l2 == l1) ? 0 : ((l1 < l2) ? -1 : 1));
  788.   }
  789.  
  790.  
  791. char *strfind(s1,s2,fast)  
  792.   
  793.   register char *s1;
  794.   char *s2;
  795.   Bool fast;
  796.   
  797. {  
  798.   register int len1,len2;
  799.   len2 = strlen(s2);
  800.   if (fast) {
  801.      while (*s1 != '\0')
  802.        if (0 == strncmp(s1++,s2,len2)) return(s1-1);
  803.   }  
  804.   else {
  805.      len1 = strlen(s1);
  806.      while (len1 >= len2) {
  807.        if (0 == strncmp(s1++,s2,len2)) return(s1-1);
  808.        len1--;
  809.      }
  810.   }
  811.   return(0);
  812. }     
  813.  
  814.  
  815. char *strncfind(s1,s2,fast)
  816.  
  817.   register char *s1;
  818.   char *s2;
  819.   Bool fast;
  820.   
  821. {  
  822.   register int len1,len2;
  823.   len2 = strlen(s2);
  824.   if (fast) {
  825.      while (*s1 != '\0')
  826.        if (0 == nocase_compare(s1++,len2,s2,len2)) return(s1-1);
  827.   }
  828.   else {
  829.      len1 = strlen(s1);
  830.      while (len1 >= len2) {
  831.        if (0 == nocase_compare(s1++,len2,s2,len2)) return(s1-1);
  832.        len1--;
  833.      }
  834.   }
  835.   return(0);
  836. }  
  837.  
  838.   
  839. char *strsearch(s1,s1len,s2,s2len)
  840.  
  841.   /* do a substring search without noticing nulls */
  842.   /* finds s2 in s1, returns pointer into s1 or 0 */
  843.  
  844.   register char *s1, *s2;
  845.   register int s1len,s2len;
  846.   
  847.   {  register char *pc;
  848.      register char *bound;
  849.      register char *pctemp;
  850.      register char *s2temp;
  851.      register int j;
  852.  
  853.      bound = s1 + s1len - s2len;
  854.      for (pc = s1; pc <= bound; pc++) {
  855.          pctemp = pc;
  856.          s2temp = s2;
  857.          for (j = 0; j < s2len; j++)
  858.              if (*pctemp++ != *s2temp++) goto not_here;
  859.          return(pc);       
  860.          not_here :
  861.          continue;
  862.      }    
  863.      return(0);
  864. }
  865.  
  866.  
  867. char *strncsearch(s1,s1len,s2,s2len)
  868.  
  869.   /* do a substring search without noticing nulls */
  870.   /* finds s2 in s1, returns pointer into s1 or 0 */
  871.   /* case independent */
  872.  
  873.   register char *s1, *s2;
  874.   register int s1len,s2len;
  875.   
  876.   {  register char *pc;
  877.      register char *bound;
  878.      register char *pctemp;
  879.      register char *s2temp;
  880.      register int j;
  881.      char ch1, ch2;
  882.  
  883.      bound = s1 + s1len - s2len;
  884.      for (pc = s1; pc <= bound; pc++) {
  885.          pctemp = pc;
  886.          s2temp = s2;
  887.          for (j = 0; j < s2len; j++) {
  888.              ch1 = *pctemp++;
  889.              ch2 = *s2temp++;
  890.              if (to_upper_if_lower(ch1) != to_upper_if_lower(ch2))
  891.                 goto not_here;
  892.          }
  893.          return(pc);       
  894.          not_here :
  895.          continue;
  896.      }    
  897.      return(0);
  898. }
  899.  
  900.  
  901. int remove_excess_blanks (newstring,oldstring) 
  902.  
  903.   /* it is assumed that newstring is as long as oldstring if necessary */
  904.  
  905.   char *newstring,*oldstring;
  906.  
  907. {
  908.   int count = 0;
  909.   int space_found = 0;
  910.  
  911.   /* skip over all blanks at beginning */
  912.   
  913.   if (*oldstring == ' ') {
  914.      while (*oldstring == ' ') oldstring++;
  915.   }
  916.  
  917.   while (*oldstring != '\0') {
  918.         if (space_found && *oldstring == ' ') {
  919.            oldstring++;
  920.            continue;
  921.         }
  922.         space_found = (*oldstring == ' ');
  923.         *newstring++ = *oldstring++;
  924.         count++;
  925.   }
  926.  
  927.   *newstring = '\0';
  928.   if (count > 0 && *(newstring - 1) == ' ') {
  929.      count--;
  930.      *(newstring - 1) = '\0';
  931.   }
  932.  
  933.   return(count);
  934.  
  935. }
  936.  
  937. int ip_string_trim (oldstring,trimchars,pretrim,posttrim)
  938.  
  939.   char *oldstring, *trimchars;
  940.   Bool pretrim,posttrim;
  941.  
  942. {
  943.   Bool trim = T;
  944.   char *np = oldstring, ch;
  945.   int len;
  946.   
  947.   if (pretrim) {
  948.      while (trim && ('\0' != (ch = *np))) {
  949.        trim = (0 != index(trimchars,ch));
  950.        if (trim) np++;
  951.      }
  952.      strcpy(oldstring,np);
  953.   }
  954.   if (1 >= (len = strlen(oldstring)) && pretrim) return(len);
  955.   if (posttrim) {
  956.      np = oldstring + len - 1;
  957.      while (T) {
  958.        ch = *np;
  959.        trim = (0 != index(trimchars,ch));
  960.        if (trim) *np == '\0';
  961.        if (!trim || np == oldstring) break;
  962.        np--;
  963.      }
  964.   }
  965.   return(strlen(oldstring));
  966. }
  967.   
  968. int string_trim (newstring,oldstring,trimchars,pretrim,posttrim)
  969.  
  970.   char *newstring, *oldstring, *trimchars;
  971.   Bool pretrim, posttrim;
  972.   
  973. {  
  974.   strcpy(newstring,oldstring);
  975.   return(ip_string_trim(newstring,trimchars,pretrim,posttrim));
  976. }
  977.  
  978. char *string_upcase (astring) char *astring;
  979. {
  980.   while (*astring) {
  981.     *astring = to_upper_if_lower(*astring);
  982.     astring++;
  983.   }
  984. }
  985.  
  986. char *string_downcase (astring) char *astring;
  987. {
  988.   while (*astring) {
  989.     *astring = to_lower_if_upper(*astring);
  990.     astring++;
  991.   }
  992. }
  993.  
  994.  
  995. yes_or_no_check (astring) char *astring;
  996.  
  997. /* returns 1 if yes, 0 if no, -1 if neither */
  998. /* works for 'Y' 'YES' 'NO' 'N' in any capitalization */
  999.  
  1000. {  
  1001.   int len;
  1002.   len = strlen(astring);
  1003.   if (len == 0 || len > 3) return(-1);
  1004.   if (0 == nocase_compare(astring,len,"YES",3) || 
  1005.       0 == nocase_compare(astring,len,"Y",1))
  1006.      return(1);
  1007.   if (0 == nocase_compare(astring,len,"NO",2) || 
  1008.       0 == nocase_compare(astring,len,"N",1))
  1009.      return(0);
  1010.   return(-1);
  1011. }
  1012.  
  1013.  
  1014. Bool all_digits (astring) char *astring;
  1015.  
  1016. /* test whether every character is a digit (0-9) */
  1017.  
  1018. {
  1019.   while (*astring != '\0') 
  1020.     if (!isdigit(*astring++)) return(F);
  1021.   return(T);
  1022. }
  1023.  
  1024.  
  1025. Bool all_whitespace (astring) char *astring;
  1026.  
  1027. /* test whether every character is a blank or a tab */
  1028.  
  1029. {
  1030.   register char ch;
  1031.   while ((ch = *astring++) != '\0') {
  1032.     if (ch == ' ' || ch == '\t') continue;
  1033.     return(F);
  1034.   }
  1035.   return(T);
  1036. }
  1037.  
  1038. Bool all_uppercase(astring) char *astring;
  1039. {
  1040.   register char ch;
  1041.   while ((ch = *astring++) != '\0') {
  1042.     if (!isupper(ch)) return(F);
  1043.   }
  1044.   return(T);
  1045. }
  1046.  
  1047. Bool all_lowercase(astring) char *astring;
  1048. {
  1049.   register char ch;
  1050.   while ((ch = *astring++) != '\0') {
  1051.     if (!islower(ch)) return(F);
  1052.   }
  1053.   return(T);
  1054. }
  1055.  
  1056. Bool all_alphabetic(astring) char *astring;
  1057. {
  1058.   register char ch;
  1059.   while ((ch = *astring++) != '\0') {
  1060.     if (!isalpha(ch)) return(F);
  1061.   }
  1062.   return(T);
  1063. }
  1064.  
  1065. Bool all_ascii(astring) char *astring;
  1066. {
  1067.   register char ch;
  1068.   while ((ch = *astring++) != '\0') {
  1069.     if (!isascii(ch)) return(F);
  1070.   }
  1071.   return(T);
  1072. }
  1073.  
  1074. Bool all_alphanumeric(astring) char *astring;
  1075. {
  1076.   register char ch;
  1077.   while ((ch = *astring++) != '\0') {
  1078.     if (!isalnum(ch)) return(F);
  1079.   }
  1080.   return(T);
  1081. }
  1082.  
  1083. int str_to_pos_int (astring,low,high) char *astring; int low,high;
  1084.  
  1085.   /* returns -1 if *astring is not composed of digits. */
  1086.   /* returns -2 if the integer is out of range. */
  1087.   /* treats all digit strings as decimal. */
  1088.  
  1089. {
  1090.   int value,len,maxlen,j;
  1091.   maxlen = strlen(MAXINTSTR);
  1092.   len = strlen(astring);
  1093.   if (!all_digits(astring)) return(-1);
  1094.   if (len > maxlen) return(-2);
  1095.   if (len == maxlen) {
  1096.      if (1 == strcmp(astring,MAXINTSTR)) return(-2);
  1097.   }
  1098.   for (j = 0; j < len-1; j++) {
  1099.       if (*astring != '0') break;
  1100.       astring++;
  1101.   }
  1102.   sscanf(astring,"%d",&value);
  1103.   if (value < low || value > high) return(-2);
  1104.   return(value);
  1105. }
  1106.  
  1107.  
  1108. int sreverse (buffer,astring) char *buffer, *astring;
  1109. {
  1110.   register int last = strlen(astring);
  1111.   buffer[last--] = '\0';
  1112.   while (last >= 0) buffer[last--] = *astring++;
  1113. }
  1114.  
  1115. char * ip_sreverse (astring) char *astring;
  1116. {
  1117.   register int last = strlen(astring) - 1;
  1118.   register int first = 0;
  1119.   register char ch;
  1120.   while (first < last) {
  1121.     ch = astring[first];
  1122.     astring[first++] = astring[last];
  1123.     astring[last--] = ch;
  1124.   }
  1125.   return(astring);
  1126. }
  1127.  
  1128.  
  1129.  
  1130. static char pathbuffer[PATH_MAXPATHLEN];
  1131.  
  1132.  
  1133. char *temp_path (dir,filename) char *dir; char *filename;
  1134.  
  1135. {
  1136.   return(make_path(dir,filename,"",F));
  1137. }
  1138.  
  1139.  
  1140. char *perm_path (dir,filename) char *dir; char *filename;
  1141.  
  1142. {
  1143.   return(make_path(dir,filename,"",T));
  1144. }
  1145.  
  1146.  
  1147. char *make_path_numeric_extension (dir,filename,extension,perm)
  1148.  
  1149.   char *dir, *filename;
  1150.   int extension;
  1151.   Bool perm;
  1152.  
  1153. {
  1154.   char buffer[20];
  1155.   sprintf(buffer,"%d",extension);
  1156.   return(make_path(dir,filename,buffer,perm));
  1157. }
  1158.  
  1159.  
  1160. char *make_path (dir,filename,extension,perm)
  1161.  
  1162.   char *dir, *filename, *extension;
  1163.   Bool perm;
  1164.  
  1165. {
  1166.   char *rval;
  1167.   if (!perm && (strlen(dir) + 1 + strlen(filename) + strlen(extension) + 1 >=
  1168.                 PATH_MAXPATHLEN)) {
  1169.      return((char *) 0);
  1170.   }
  1171.   nbuffconcat(pathbuffer,4,dir,"/",filename,extension);
  1172.   if (!perm) return(pathbuffer);
  1173.   rval = emalloc(strlen(pathbuffer) + 1);  
  1174.   strcpy(rval,pathbuffer);
  1175.   return(rval);
  1176. }
  1177.  
  1178.  
  1179. char *just_filename (path,new,perm) char *path; Bool new,perm;
  1180.  
  1181. {
  1182.   char *fnp,*rval;
  1183.   fnp = (0 == (fnp = rindex(path,'/'))) ? path : fnp + 1;
  1184.   if (!new) return(fnp);
  1185.   if (!perm) {
  1186.      strcpy(pathbuffer,fnp);
  1187.      return(pathbuffer);
  1188.   }
  1189.   else {
  1190.      rval = emalloc(strlen(fnp) + 1);
  1191.      strcpy(rval,fnp);
  1192.      return(rval);
  1193.   }
  1194. }
  1195.  
  1196.  
  1197.  
  1198. read_yes_or_no (iport,oport,prompt,helpstring,quitstring)
  1199.  
  1200.   /* prints prompt, then reads from port until it gets 'Y', 'N', 'YES' or */
  1201.   /* 'NO' (case independently).  If helpstring and/or quitstring are not */
  1202.   /* "" or (char *) 0 then if the user types in one of those ANSWER_HELP */
  1203.   /* or ANSWER_QUIT are returned, otherwise ANSWER_NO or ANSWER_YES are */
  1204.   /* eventually returned. */
  1205.  
  1206.   FILE *iport, *oport;
  1207.   char *prompt, *helpstring, *quitstring;
  1208.  
  1209. {
  1210.   char buffer[20],buffer2[20];
  1211.   int bl,hl,ql,len;
  1212.   
  1213.   buffer[19] = '\0';
  1214.   
  1215.   while (T) {
  1216.         
  1217.     fprintf(oport,"%s",prompt);
  1218.     switch (len = getline(iport,buffer,20)) {
  1219.       case (AT_EOF) :
  1220.         return(ANSWER_EOF);
  1221.         break;
  1222.       case (TOO_MANY_CHARS) :
  1223.         break;
  1224.       default :
  1225.         if (0 == (bl = remove_excess_blanks(buffer2,buffer))) break;
  1226.         switch (yes_or_no_check(buffer2)) {
  1227.           case (0) :
  1228.             return(ANSWER_NO);
  1229.           case (1) :
  1230.             return(ANSWER_YES);
  1231.           case (-1) :
  1232.             if (helpstring != (char *) 0 && (hl = strlen(helpstring)) > 0) {
  1233.                if (0 == nocase_compare(buffer2,bl,helpstring,hl)) {
  1234.                   return(ANSWER_HELP);
  1235.                }
  1236.             }
  1237.             if (quitstring != (char *) 0 && (ql = strlen(quitstring)) > 0) {
  1238.                if (0 == nocase_compare(buffer2,bl,quitstring,ql)) {
  1239.                   return(ANSWER_QUIT);
  1240.                }
  1241.             }
  1242.             break;
  1243.         }   
  1244.         break;
  1245.     }
  1246.    
  1247.     fprintf(oport,"Please answer 'YES' or 'NO'\n");
  1248.     continue;
  1249.    
  1250.   }
  1251.     
  1252. }
  1253.  
  1254.  
  1255. int getline (iport,buffer,buflen) FILE *iport; char *buffer; int buflen;
  1256.  
  1257.   /* reads a line into buffer.  Does not put the '\n' into buffer. */
  1258.   /* Returns AT_EOF if at end of file when called.  If it encounters */
  1259.   /* end of file after reading at least one character, the eof is treated */
  1260.   /* as if it were a newline.   Returns TOO_MANY_CHARS if more than */
  1261.   /* buflen - 1 characters are read before encountering a newline. */        
  1262.   /* In this case exactly buflen - 1 characters are read. */
  1263.   /* The last character read is always follwed by a '\0'. */
  1264.   /* if successful getline returns the number of characters read exclusive */
  1265.   /* of a terminating newline or eof. */
  1266.  
  1267. {
  1268.   int ch;
  1269.   char *bptr = buffer;
  1270.   int nchars = 0;
  1271.   
  1272.   if (buflen <= 0) return(TOO_MANY_CHARS);
  1273.   
  1274.   while (T) {
  1275.     switch (ch = getc(iport)) {
  1276.       case (EOF) :
  1277.       case ('\n') :
  1278.         if (ch == EOF && nchars == 0) return(AT_EOF);
  1279.         *bptr = '\0';
  1280.         return(nchars);
  1281.       default :
  1282.         if (++nchars == buflen) { 
  1283.            *bptr = '\0';
  1284.            ungetc(ch,iport);
  1285.            return(TOO_MANY_CHARS);
  1286.         }
  1287.         *bptr++ = ch;
  1288.     }
  1289.     
  1290.   }
  1291.     
  1292. }
  1293.  
  1294.  
  1295. int getlines (fp,n,ptr_lines,linebuf,maxlinelen)
  1296.  
  1297.   /* See documentation for getfile below */
  1298.  
  1299.   FILE *fp;
  1300.   int n;
  1301.   char ***ptr_lines;
  1302.   char *linebuf;
  1303.   int maxlinelen;
  1304.  
  1305. {
  1306.   int len;
  1307.   char *line;
  1308.   if (0 > (len = getline(fp,linebuf,maxlinelen))) {
  1309.      if (len == AT_EOF) {
  1310.         *ptr_lines = (char **) emalloc(n * sizeof(char **));
  1311.         return(n);
  1312.      }
  1313.      else {
  1314.         return(TOO_MANY_CHARS);
  1315.      }
  1316.   }
  1317.   else {
  1318.      line = emalloc(len+1);
  1319.      strcpy(line,linebuf);
  1320.      len = getlines(fp,n+1,ptr_lines,linebuf,maxlinelen);
  1321.      if (len == TOO_MANY_CHARS) return(TOO_MANY_CHARS);
  1322.      (*ptr_lines)[n] = line;
  1323.      return(len);
  1324.   }
  1325. }
  1326.  
  1327.  
  1328. int getfile (filename,ptr_lines,linebuf,maxlinelen)
  1329.  
  1330.   /* read in a file as an array of character strings */
  1331.   /* 'maxlinelen+1' is the maximum length a line of the file is allowed */
  1332.   /* to be.  'linebuf' must be at least 'maxlinelen+1' characters long. */
  1333.   /* Returns the number of lines in the file (and therefore the number */
  1334.   /* of entries in *ptr_lines) if successful.  Returns IOERROR if it */
  1335.   /* could not open the file to read from. Returns TOO_MANY_CHARS if */
  1336.   /* it encounters a line longer than 'maxlinelen' characters. */
  1337.  
  1338.   /* Space for each line is malloc'ed as it is read in and the text for */
  1339.   /* the jth line is stored in (*ptr_lines)[j] */
  1340.  
  1341.   char *filename;
  1342.   char ***ptr_lines;
  1343.   char *linebuf;
  1344.   int maxlinelen;
  1345.  
  1346. {
  1347.   FILE *fp;
  1348.   int nlines;
  1349.   if (NULL == (fp = fopen(filename,"r"))) return(IOERROR);
  1350.   nlines = getlines(fp,0,ptr_lines,linebuf,maxlinelen);
  1351.   fclose(fp);
  1352.   return(nlines);
  1353. }
  1354.  
  1355.  
  1356. int ngetlines (fp,n,ptr_lines,linebuf,maxlinelen)
  1357.  
  1358.   /* See documentation for ngetfile below */
  1359.  
  1360.   FILE *fp;
  1361.   int n;
  1362.   char ***ptr_lines;
  1363.   char *linebuf;
  1364.   int maxlinelen;
  1365.  
  1366. {
  1367.   int len;
  1368.   int nlines = 0;
  1369.   *ptr_lines = (char **) emalloc(n * sizeof(char **));
  1370.   while (T) {
  1371.     if (0 > (len = getline(fp,linebuf,maxlinelen))) {
  1372.        if (len == AT_EOF) {
  1373.           return(nlines);
  1374.        }
  1375.        else {
  1376.           return(TOO_MANY_CHARS);
  1377.        }
  1378.     }
  1379.     else {
  1380.        if (++nlines > n) {
  1381.           return(TOO_MANY_LINES);
  1382.        }
  1383.        (*ptr_lines)[nlines-1] = anewstr(linebuf);
  1384.     }
  1385.   }
  1386. }
  1387.  
  1388.  
  1389.  
  1390. int ngetfile (n,filename,ptr_lines,linebuf,maxlinelen)
  1391.  
  1392.   /* Same as getfile except that at most n lines will be read. */
  1393.   /* If it attempts to read more than n lines, TOO_MANY_LINES will */
  1394.   /* be returned. */
  1395.  
  1396.   int n;
  1397.   char *filename;
  1398.   char ***ptr_lines;
  1399.   char *linebuf;
  1400.   int maxlinelen;
  1401.  
  1402. {
  1403.   FILE *fp;
  1404.   int nlines;
  1405.   if (NULL == (fp = fopen(filename,"r"))) return(IOERROR);
  1406.   nlines = ngetlines(fp,n,ptr_lines,linebuf,maxlinelen);
  1407.   fclose(fp);
  1408.   return(nlines);
  1409. }
  1410.  
  1411.  
  1412. extern int read_file_into_buffer (
  1413.  
  1414.        filename,ptr_lines,maxlines,buffer,buflen,linebuffer,linebuflen
  1415.  
  1416.     )
  1417.        
  1418.   char *filename; 
  1419.   char ***ptr_lines;
  1420.   int maxlines;
  1421.   char *buffer;
  1422.   int buflen;
  1423.   char *linebuffer;
  1424.   int linebuflen;
  1425.  
  1426.   /* *ptr_lines should be an array of character string pointers maxlines */
  1427.   /* big.  buffer should be an array of characters buflen long.  The routine */
  1428.   /* reads lines using getline and stores them into buffer, terminating each */
  1429.   /* with a null.  A pointer to the nth line read is stored in *ptr_lines[n] */
  1430.   /* Returns IOERROR if it cannot open the file for reading, TOO_MANY_LINES */
  1431.   /* if more than maxlines were read in, TOO_MANY_CHARS if buffer is */
  1432.   /* filled before end of file is reached, and LINE_TOO_LONG is any line is */
  1433.   /* longer than linebuflen.  Returns number of lines read in if successful. */
  1434.   
  1435. {  
  1436.   FILE *fp;
  1437.   int linecount,charcount,len;
  1438.   char *bp;
  1439.   char **lines;
  1440.   
  1441.   if (NULL == (fp = fopen(filename,"r"))) return(IOERROR);
  1442.   linecount = 0;
  1443.   charcount = 0;
  1444.   bp = buffer;
  1445.   lines = *ptr_lines;
  1446.   
  1447.   while (T) {
  1448.         
  1449.     if (0 > (len = getline(fp,linebuffer,linebuflen))) {
  1450.        fclose(fp);
  1451.        if (len == AT_EOF) {
  1452.           return(linecount);
  1453.        }
  1454.        else {
  1455.           return(LINE_TOO_LONG);
  1456.        }
  1457.     }
  1458.     
  1459.     if (linecount >= maxlines) {
  1460.        fclose(fp);
  1461.        return(TOO_MANY_LINES);
  1462.     }
  1463.     
  1464.     charcount += len;
  1465.     if (charcount >= buflen) {
  1466.        fclose(fp);
  1467.        return(TOO_MANY_CHARS);
  1468.     }
  1469.     
  1470.     strcpy(bp,linebuffer);
  1471.     lines[linecount++] = bp;
  1472.     bp += (len + 1);
  1473.   
  1474.   }
  1475.   
  1476. }
  1477.   
  1478. extern char *efopen (filename,mode) char *filename; char *mode;
  1479.  
  1480.   /* The routine simply calls fopen with the same arguments, but prints a */
  1481.   /* reasonable error message and calls exit if the call to fopen fails. */
  1482.  
  1483. {
  1484.   FILE *fp;
  1485.   if (NULL == (fp = fopen(filename,mode))) {
  1486.      fprintf(stderr,"Could not open %s, mode: %s\n",filename,mode);
  1487.      perror("Reason: ");
  1488.      exit(1);
  1489.   }
  1490.   return((char *) fp);
  1491. }
  1492.  
  1493.  
  1494.  
  1495. extern int record_fseek (fp,rnum,fromwhere,rsize,hdrsize)
  1496.  
  1497.   FILE *fp;
  1498.   long rnum;
  1499.   int fromwhere;
  1500.   int rsize;
  1501.   int hdrsize; 
  1502.  
  1503. {
  1504.   if (fromwhere == 0) {
  1505.      return(fseek(fp,(long) ((rnum - 1)*rsize + hdrsize),0));
  1506.   }
  1507.   else {
  1508.      return(fseek(fp,(long) (rnum*rsize),fromwhere));
  1509.   }
  1510. }
  1511.  
  1512.  
  1513. Bool check_string (s,minlen,maxlen) char *s; long minlen,maxlen;
  1514. {
  1515.   long len;
  1516.   if (s == 0) return(F);
  1517.   len = strlen(s);
  1518.   return (len >= minlen && len <= maxlen);
  1519. }
  1520.  
  1521. SHAR_EOF
  1522. if test 20370 -ne "`wc -c < 'toolsdir/ctools.c'`"
  1523. then
  1524.     echo shar: error transmitting "'toolsdir/ctools.c'" '(should have been 20370 characters)'
  1525. fi
  1526. fi
  1527. echo shar: extracting "'toolsdir/ctools.h'" '(11301 characters)'
  1528. if test -f 'toolsdir/ctools.h'
  1529. then
  1530.     echo shar: will not over-write existing file "'toolsdir/ctools.h'"
  1531. else
  1532. cat << \SHAR_EOF > 'toolsdir/ctools.h'
  1533. /* -*- Mode: C; Package: (CTOOLS C) -*- */
  1534.  
  1535. #ifndef Bool
  1536. #define Bool int
  1537. #endif
  1538.  
  1539. #ifndef T
  1540. #define T 1
  1541. #endif
  1542.  
  1543. #ifndef F
  1544. #define F 0
  1545. #endif
  1546.  
  1547. #ifndef MAXINT
  1548. #define MAXINT 2147483647
  1549. #define MAXINTSTR "2147483647"
  1550. #endif
  1551.  
  1552. #ifndef MAXPATHLEN
  1553. #define MAXPATHLEN 80
  1554. #endif
  1555.  
  1556. extern char *emalloc();
  1557.  
  1558.   /* int space; */
  1559.   /* space must be greater than 0 */
  1560.   /* Causes executution to halt with a 'Fatal error' message if memory */
  1561.   /* cannot be allocated, otherwise returns pointer to malloc-ed space */
  1562.  
  1563. extern char *anewstr();
  1564.  
  1565.   /* char *astring; */
  1566.   /* emalloc's space and copies astring into that space.  Returns pointer */
  1567.   /* to new string. */
  1568.  
  1569.  
  1570. extern int copy();
  1571.  
  1572.   /* char *dest, *src; int n; */
  1573.   /* copies exactly n bytes. */
  1574.   /* return value undefined.  Use only as procedure. */
  1575.  
  1576. extern int fill();
  1577.  
  1578.   /* char *addr, ch; int n; */
  1579.   /* copies ch into n consecutive bytes. */
  1580.   /* return value undefined.  Use only as procedure. */
  1581.  
  1582. extern int to_upper_if_lower();
  1583.  
  1584.   /* char ch;  Returns possibly upper-cased value. */
  1585.  
  1586. extern int to_lower_if_upper();
  1587.  
  1588.   /* char ch;  Returns possibly lower-cased value. */
  1589.  
  1590. extern int buffconcat();
  1591.  
  1592.   /* char *buffer, *s1, *s2; */
  1593.   /* s1 and s2 must be null terminated.  Buffer must be at least */
  1594.   /* strlen(s1) + strlen(s2) + 1 characters long.  Buffer is null */
  1595.   /* terminated upon completion. */
  1596.  
  1597.   /* return value undefined.  Use only as procedure. */
  1598.  
  1599. extern int nbuffconcat();
  1600.  
  1601.   /* char *buffer; int n; char *s1,*s2,*s3,*s4,*s5,*s6; */
  1602.   /* all the strings must be null terminated.  Buffer must be big enough */
  1603.   /* to hold the null terminated result.  0 < n < 7 .. 
  1604.   /* returns -1 if n is out of range, otherwise 0 */
  1605.  
  1606. extern int slcompare();
  1607.  
  1608.   /* char *s1; int l1; char *s2; int l2 */
  1609.   /* does not stop if it encounters a null character. */
  1610.   /* returns 0 if equal, -1 if not equal */
  1611.  
  1612. extern int slge_compare();
  1613.  
  1614.   /* char *s1; int l1; char *s2; int l2 */
  1615.   /* does not stop if it encounters a null character. */
  1616.   /* returns 0 if equal, -1 if s1 < s2, 1 if s1 > s2 */
  1617.  
  1618. extern int nocase_compare();
  1619.  
  1620.   /* char *s1; int l1; char *s2; int l2 */
  1621.   /* does not stop if it encounters a null character. */
  1622.   /* returns 0 if equal, -1 if s1 < s2, 1 if s1 > s2  case independently. */
  1623.  
  1624. extern char * strfind();
  1625.  
  1626.   /* char *s1; char *s2; int fast; */
  1627.   /* finds s2 as a substring of s1.  s1 and s2 are null terminated. */
  1628.   /* returns 0 if not found, otherwise pointer into s1 to first matching */
  1629.   /* character. */
  1630.  
  1631.   /* WARNING:  will access off the end of s1 in the interest of efficiency */
  1632.   /* if 'fast' is non-zero. */
  1633.  
  1634. extern char * strncfind();
  1635.  
  1636.   /* char *s1; char *s2; int fast; */
  1637.   /* finds s2 as a substring of s1 case independently.  s1 and s2 are */
  1638.   /* null terminated. */
  1639.   /* returns 0 if not found, otherwise pointer into s1 to first matching */
  1640.   /* character. */
  1641.  
  1642.   /* WARNING:  will access off the end of s1 in the interest of efficiency */
  1643.   /* if 'fast' is non-zero. */
  1644.  
  1645. extern char * strsearch();
  1646.  
  1647.   /* char *s1; int l1; char *s2; int l2 */
  1648.   /* finds s2 as a substring of s1.  Does not stop if it encounters a null. */
  1649.   /* returns pointer into s1, otherwise (char *) 0 if search fails */
  1650.   /* case dependent */
  1651.  
  1652. extern char * strncsearch();
  1653.  
  1654.   /* char *s1; int l1; char *s2; int l2 */
  1655.   /* finds s2 as a substring of s1. */
  1656.   /* returns pointer into s1, otherwise (char *) 0 if search fails */
  1657.   /* case independent */
  1658.  
  1659. extern int remove_excess_blanks();
  1660.  
  1661.   /* char *newstring, *oldstring; */
  1662.   /* newstring must be long enough to hold the result, which may be as */
  1663.   /* long as oldstring.  oldstring must be null terminated. */
  1664.   /* an excess blank is any blank before the first non-blank character, */
  1665.   /* any blank after the last non-blank character, and any blank immediately */
  1666.   /* following a blank. */
  1667.   /* returns length of newstring */
  1668.  
  1669. extern int yes_or_no_check();
  1670.  
  1671.   /* char *astring; */
  1672.   /* returns 1 for yes, 0 for no, -1 for neither. */
  1673.   /* astring must be one of "YES", "Y", "NO", "N" in any capitalization. */
  1674.  
  1675.  
  1676. /* These routines return T if every char satisfies a certain condition. */
  1677. /* These returns all returns T if given a null string. */
  1678.  
  1679. extern Bool all_digits();
  1680. extern Bool all_whitespace();
  1681. extern Bool all_uppercase();
  1682. extern Bool all_lowercase();
  1683. extern Bool all_alphabetic();
  1684. extern Bool all_alphanumeric();
  1685. extern Bool all_ascii();
  1686.  
  1687.  
  1688. extern int str_to_pos_int();
  1689.  
  1690.   /* char *astring; int low,high; */
  1691.   /* low must be >= 0. */
  1692.   /* returns -1 if *astring is not composed of digits. */
  1693.   /* returns -2 if the integer is out of range. */
  1694.   /* despite its name, 0 can be returned as a legitimate value. */
  1695.   /* treats all digit strings as decimal. */
  1696.  
  1697.  
  1698. extern int sreverse();
  1699.  
  1700.   /* char *buffer; char *astring; */
  1701.   /* puts the characters of astring in reverse order into buffer. */
  1702.   /* buffer must be at least as long as astring + 1. */
  1703.   /* buffer is null terminated when done. */
  1704.   /* No return value.  Use only as procedure. */
  1705.  
  1706. extern char *ip_sreverse();
  1707.  
  1708.   /* char *astring; */
  1709.   /* Returns astring with its characters reversed. */
  1710.   /* reversal is done in place. */
  1711.  
  1712.  
  1713.  
  1714. #define PATH_MAXPATHLEN 256
  1715.  
  1716. char *temp_path();
  1717.  
  1718. /*
  1719.   char *dir; char *filename;
  1720.  
  1721.   Returns a pointer to a character string containing the string
  1722.   <dir>/<filename>.  The pointer points to a buffer which will may get
  1723.   overwritten if any functions in this package are subsequently called.
  1724.   0 is returned if the pathname would exceed PATH_MAXPATHLEN-1 chars.
  1725. */
  1726.  
  1727.  
  1728. char *perm_path();
  1729.  
  1730. /*
  1731.   char *dir; char *filename;
  1732.  
  1733.   Same as temp_path, except the pathname string is malloc'ed and is thus
  1734.   permanent unless specifically freed by the user.  Further, no limit
  1735.   on the size of the path is made.
  1736. */
  1737.  
  1738.  
  1739. char *make_path();
  1740.  
  1741. /*
  1742.   char *dir; char *filename; char *extension; Bool perm;
  1743.  
  1744.   Creates <dir>/<filename><extension> .  The string returned is permanent
  1745.   or not depending on 'perm'.  If perm is not true, 0 will be returned if
  1746.   the resulting path exceeds PATH_MAXPATHLEN-1 chars.
  1747. */
  1748.  
  1749.  
  1750. char *make_path_numeric_extension();
  1751.  
  1752. /*
  1753.   char *dir; char *filename; int extension; Bool perm;
  1754.  
  1755.   Same as make_path except that extension is first converted into a
  1756.   string using sprintf.
  1757. */
  1758.  
  1759.  
  1760. char *just_filename();
  1761.  
  1762. /*  
  1763.   char *path; Bool new; Bool perm;
  1764.  
  1765.   Given a path of the form /<x>/<y>/<z> returns <z>.  If new is not set
  1766.   then a pointer into the original input string is returned.  If new is
  1767.   set a copy is returned, either permanent or not depending on perm.
  1768. */
  1769.  
  1770.  
  1771. #define ANSWER_NO 0
  1772. #define ANSWER_YES 1
  1773. #define ANSWER_HELP 2
  1774. #define ANSWER_QUIT 3
  1775. #define ANSWER_EOF 4
  1776.  
  1777. #define AT_EOF -1
  1778. #define TOO_MANY_CHARS -2
  1779. #define IOERROR -3
  1780. #define TOO_MANY_LINES -4
  1781. #define LINE_TOO_LONG -5
  1782.  
  1783. extern read_yes_or_no ();
  1784.  
  1785.   /* FILE *iport, *oport; char *prompt; char *helpstring; char *quitstring; */
  1786.  
  1787.   /* prints prompt, then reads from iport until is gets 'Y', 'N', 'YES' or */
  1788.   /* 'NO' (case independently).  If helpstring and/or quitstring are not */
  1789.   /* "" or (char *) 0 then if the user types in one of those ANSWER_HELP */
  1790.   /* or ANSWER_QUIT are returned, otherwise ANSWER_NO or ANSWER_YES are */
  1791.   /* eventually returned. */
  1792.  
  1793.  
  1794. extern int getline ();
  1795.  
  1796.   /* FILE *iport; char *buffer; int buflen; */
  1797.  
  1798.   /* reads a line into buffer.  Does not put the '\n' into buffer. */
  1799.   /* Returns AT_EOF if at end of file when called.  If it encounters */
  1800.   /* end of file after reading at least one character, the eof is treated */
  1801.   /* as if it were a newline.   Returns TOO_MANY_CHARS if more than */
  1802.   /* buflen - 1 characters are read before encountering a newline. */        
  1803.   /* In this case exactly buflen - 1 characters are read. */
  1804.   /* The last character read is always follwed by a '\0'. */
  1805.   /* if successful getline returns the number of characters read exclusive */
  1806.   /* of a terminating newline or eof. */
  1807.  
  1808.  
  1809. extern int getlines();
  1810.  
  1811.   /* FILE *fp; int n; char ***ptr_lines; char *linebuf; int maxlinelen; */
  1812.   /* See documentation for getfile below */
  1813.   /* If called, 'n' must have a value 0. */
  1814.  
  1815. extern int getfile();
  1816.  
  1817.   /* char *filename; char ***ptr_lines; char *linebuf; int maxlinelen; */
  1818.  
  1819.   /* read in a file as an array of character strings */
  1820.   /* 'maxlinelen+1' is the maximum length a line of the file is allowed */
  1821.   /* to be.  'linebuf' must be at least 'maxlinelen+1' characters long. */
  1822.   /* Returns the number of lines in the file (and therefore the number */
  1823.   /* of entries in *ptr_lines) if successful.  Returns IOERROR if it */
  1824.   /* could not open the file to read from. Returns TOO_MANY_CHARS if */
  1825.   /* it encounters a line longer than 'maxlinelen' characters.  
  1826.  
  1827.   /* Space for each line is malloc'ed as it is read in and the text for */
  1828.   /* the jth line is stored in (*ptr_lines)[j] */
  1829.  
  1830.   /* Only works for fairly small files as it recurses its way through the */
  1831.   /* file and does a lot of malloc-ing.  Use read_file_into_buffer or */
  1832.   /* ngetfile for large files. */
  1833.  
  1834. extern int ngetlines();
  1835.  
  1836.  /* FILE *fp; int n; char ***ptr_lines; char *linebuf; int maxlinelen; */
  1837.  /* Same as getlines, except at most 'n' lines will be read.  Returns */
  1838.  /* TOO_MANY_LINES if more than 'n' lines are present. */
  1839.  
  1840. extern int ngetfile();
  1841.  
  1842.  /* int n; char *filename; char ***ptr_lines; char *linebuf; int maxlinelen; */
  1843.  /* See ngetlines above. */
  1844.  
  1845. extern int read_file_into_buffer();
  1846.  
  1847.   /* char *filename; 
  1848.      char ***ptr_lines;
  1849.      int maxlines;
  1850.      char *buffer;
  1851.      int buflen;
  1852.      char *linebuffer;
  1853.      int linebuflen;
  1854.   */
  1855.  
  1856.   /* *ptr_lines should be an array of character string pointers maxlines */
  1857.   /* big.  buffer should be an array of characters buflen long.  The routine */
  1858.   /* reads lines using getline and stores them into buffer, terminating each */
  1859.   /* with a null.  A pointer to the nth line read is stored in *ptr_lines[n] */
  1860.   /* Returns IOERROR if it cannot open the file for reading, TOO_MANY_LINES */
  1861.   /* if more than maxlines were read in, TOO_MANY_CHARS if buffer is */
  1862.   /* filled before end of file is reached, and LINE_TOO_LONG is any line is */
  1863.   /* longer than linebuflen.  Returns number of lines read in if successful. */
  1864.  
  1865. extern char *efopen();  
  1866.  
  1867.   /* char *filename; char *mode */
  1868.  
  1869.   /* Actually returns a (FILE *), so one must cast the return value to this */
  1870.   /* type.  It doesn't return a (FILE *) explicitly because then to include */
  1871.   /* this file one would have to include <stdio.h> explicitly before it. */
  1872.   /* The routine simply calls fopen with the same arguments, but prints a */
  1873.   /* reasonable error message and calls exit if the call to fopen fails. */
  1874.  
  1875.  
  1876. extern int record_fseek();
  1877.  
  1878.   /* FILE *fp; long rnum; int fromwhere; int rsize; int hdrsize; */
  1879.  
  1880.   /* Assumes a file is divided into fixed length records with a fixed length */
  1881.   /* header (possibly 0 bytes).  Performs a fseek which moves to the start */
  1882.   /* of a given record.  Record numbers begin with 1. */
  1883.  
  1884.   /* Returns what fseek returns. */
  1885.  
  1886.   /* 'rnum' is either relative or absolute, depending on 'fromwhere' which */
  1887.   /* corresponds to the 'ptrname' argument of fseek. */
  1888.  
  1889.  
  1890. Bool check_string();
  1891.  
  1892.   /* char *str; long minlen; long maxlen; */
  1893.  
  1894.   /* Returns T if str is not 0 and has a length between minlen and maxlen */
  1895.   /* inclusived, otherwise returns F. */
  1896.  
  1897.  
  1898. #ifndef check_int
  1899. #define check_int(i,minval,maxval) ((i) >= (minval) && (i) <= (maxval))
  1900. #endif
  1901. SHAR_EOF
  1902. if test 11301 -ne "`wc -c < 'toolsdir/ctools.h'`"
  1903. then
  1904.     echo shar: error transmitting "'toolsdir/ctools.h'" '(should have been 11301 characters)'
  1905. fi
  1906. fi
  1907. echo shar: extracting "'toolsdir/mem.c'" '(2157 characters)'
  1908. if test -f 'toolsdir/mem.c'
  1909. then
  1910.     echo shar: will not over-write existing file "'toolsdir/mem.c'"
  1911. else
  1912. cat << \SHAR_EOF > 'toolsdir/mem.c'
  1913. /**************************************************************************/
  1914. /**************************************************************************/
  1915.  
  1916.  
  1917.                   /***** Block Memory Allocator *****/
  1918.  
  1919.  
  1920. /**************************************************************************/
  1921. /**************************************************************************/
  1922.  
  1923. /* Author: JP Massar */
  1924.  
  1925. #include <stdio.h>
  1926.  
  1927. #include "sys5.h"
  1928.  
  1929. #ifdef BSD42
  1930. #include <strings.h>
  1931. #endif
  1932.  
  1933. #define NO_MORE_MEMORY -1
  1934.  
  1935. static int bytes_left;                  /* space left in current block */
  1936. static char *ptr_next_byte;             /* next free byte */
  1937. static char *ptr_space;                 /* current block */
  1938. static int chunk_size;                  /* size of block last allocated */
  1939.  
  1940. extern char *malloc();
  1941.  
  1942.  
  1943. int allocate_memory_chunk (space) int space;
  1944.  
  1945. /* malloc up a new block of memory.  Set our static variables */
  1946. /* returns NO_MORE_MEMORY if can't allocate block. */
  1947.  
  1948. { 
  1949.   if (0 == (ptr_space = malloc(space))) {
  1950.         fprintf(stderr,"fatal error, no more memory\n");
  1951.         return(NO_MORE_MEMORY);
  1952.   }
  1953.   ptr_next_byte = ptr_space;
  1954.   bytes_left = space;
  1955.   chunk_size = space;
  1956.   return(0);
  1957. }
  1958.  
  1959.  
  1960. char * get_memory_chunk (size) int size;
  1961.  
  1962. /* allocate a small segment out of our large block of memory.  If we */
  1963. /* run out allocate another block.  Adjust our static variables. */
  1964. /* returns 0 if no more memory. */
  1965.  
  1966. { char *rval;
  1967.         
  1968.   if (size > chunk_size) {
  1969.         fprintf(stderr,"attempt to allocate too large a chunk\n");
  1970.         return(0);
  1971.   }
  1972.         
  1973.   if (size > bytes_left) {
  1974.         if (NO_MORE_MEMORY == allocate_memory_chunk(chunk_size)) {
  1975.                 return(0);
  1976.         }
  1977.         return(get_memory_chunk(size));
  1978.   }
  1979.  
  1980.   rval = ptr_next_byte;
  1981.   ptr_next_byte += size;
  1982.   bytes_left -= size;
  1983.   return(rval);
  1984.   
  1985. }
  1986.  
  1987.  
  1988. char * store_string (str,len) char *str; int len;
  1989.  
  1990. /* put copy of a string into storage in a memory block.  Return a pointer to */
  1991. /* the copied string.  Returns 0 if out of memory. */
  1992.  
  1993. { char *ptr_space;
  1994.  
  1995.   if (0 == (ptr_space = get_memory_chunk(len+1))) {
  1996.         return(0);
  1997.   }
  1998.   strcpy(ptr_space,str);
  1999.   return(ptr_space);
  2000. }
  2001. SHAR_EOF
  2002. if test 2157 -ne "`wc -c < 'toolsdir/mem.c'`"
  2003. then
  2004.     echo shar: error transmitting "'toolsdir/mem.c'" '(should have been 2157 characters)'
  2005. fi
  2006. fi
  2007. echo shar: extracting "'toolsdir/mem.h'" '(209 characters)'
  2008. if test -f 'toolsdir/mem.h'
  2009. then
  2010.     echo shar: will not over-write existing file "'toolsdir/mem.h'"
  2011. else
  2012. cat << \SHAR_EOF > 'toolsdir/mem.h'
  2013. extern int allocate_memory_chunk();     /* arg1: int space */
  2014.        
  2015. extern char * get_memory_chunk();       /* arg1: int size */
  2016.  
  2017. extern char * store_string();           /* arg1: char *str, arg2: int len */
  2018. SHAR_EOF
  2019. if test 209 -ne "`wc -c < 'toolsdir/mem.h'`"
  2020. then
  2021.     echo shar: error transmitting "'toolsdir/mem.h'" '(should have been 209 characters)'
  2022. fi
  2023. fi
  2024. echo shar: extracting "'toolsdir/menu.c'" '(7644 characters)'
  2025. if test -f 'toolsdir/menu.c'
  2026. then
  2027.     echo shar: will not over-write existing file "'toolsdir/menu.c'"
  2028. else
  2029. cat << \SHAR_EOF > 'toolsdir/menu.c'
  2030. #include <stdio.h>
  2031. #include <varargs.h>
  2032. #include "ctools.h"
  2033. #include "menu.h"
  2034. #include "sys5.h"
  2035.  
  2036.  
  2037. static char line[MAX_MENU_RESPONSE_LENGTH];
  2038.  
  2039.  
  2040. menu_match (
  2041.  
  2042.      ptr_rval,ptr_ur,prompt,casetest,isub,r_no_match,r_ambiguous,n_options,
  2043.      va_alist
  2044.      
  2045.    )
  2046.  
  2047.   int *ptr_rval;
  2048.   char **ptr_ur;
  2049.   char *prompt;
  2050.   int casetest;
  2051.   int isub;
  2052.   int r_no_match;
  2053.   int r_ambiguous;
  2054.   int n_options;
  2055.   va_dcl
  2056.     
  2057. {
  2058.  
  2059.   char sline[MAX_MENU_RESPONSE_LENGTH];
  2060.   char *option, *options[MAX_MENU_OPTIONS];
  2061.   int rvals[MAX_MENU_OPTIONS];
  2062.   int j,found,*addr,len,optionlen,rval,compare,blankindex;
  2063.   va_list pvar;
  2064.         
  2065.   if (n_options > MAX_MENU_OPTIONS) return(MENU_ERROR);
  2066.   for (j = 0; j < MAX_MENU_RESPONSE_LENGTH; j++) line[j] = ' ';
  2067.   
  2068.   /* grab all the menu options and return values.  */
  2069.   
  2070.   blankindex = -1;
  2071.   va_start(pvar);
  2072.   for (j = 0; j < n_options; j++) {
  2073.       options[j] = va_arg(pvar,char *);
  2074.       if (0 == strlen(options[j])) {
  2075.          if (blankindex == -1) blankindex = j;
  2076.       }
  2077.       rvals[j] = va_arg(pvar,int);
  2078.   }
  2079.   va_end(pvar);
  2080.   
  2081.   try_again :
  2082.   
  2083.   /* get the user's response */
  2084.   
  2085.   printf("%s",prompt);
  2086.   switch (rval = getline(stdin,line,MAX_MENU_RESPONSE_LENGTH)) {
  2087.     case AT_EOF :
  2088.       return(MENU_EOF);
  2089.       break;
  2090.     case TOO_MANY_CHARS :
  2091.      fprintf(stderr,"Response is too long to handle.  Please try again\n");
  2092.      goto try_again;
  2093.      break;
  2094.    default :
  2095.      *ptr_ur = line;
  2096.      remove_excess_blanks(sline,line);
  2097.      len = strlen(sline);
  2098.      break;
  2099.  }
  2100.     
  2101.   found = 0;
  2102.   rval = MENU_NO_MATCH;
  2103.   
  2104.   if (all_whitespace(sline)) {
  2105.      if (blankindex == -1) goto try_again;
  2106.      rval = MENU_MATCH;
  2107.      *ptr_rval = rvals[blankindex];
  2108.      goto rtn;
  2109.   }     
  2110.   
  2111.   for (j = 0; j < n_options; j ++) {
  2112.  
  2113.       /* if what he typed in is longer than any option it can't match */
  2114.         
  2115.       optionlen = strlen(options[j]);
  2116.       if (len > optionlen) continue;  
  2117.       
  2118.       /* if we aren't matching initial substrings, the response must */
  2119.       /* match exactly. */
  2120.       
  2121.       if (!isub && len != optionlen) continue;
  2122.       
  2123.       /* use different comparision functions depending on whether case */
  2124.       /* is important or not. */
  2125.       
  2126.       compare = casetest ? 
  2127.                 strncmp(sline,options[j],len) : 
  2128.                 nocase_compare(sline,len,options[j],len);
  2129.                 
  2130.       /* if we must match exactly, if we find a match exit immediately. */
  2131.       /* if we can match on an initial substring, if we've already found */
  2132.       /* a match then we have an ambiguity, otherwise note that we've */
  2133.       /* matched and continue looking in case of ambiguities */
  2134.                 
  2135.       if (0 == compare) {
  2136.          if (!isub) {
  2137.             found = 1;
  2138.             *ptr_rval = rvals[j];
  2139.             rval = MENU_MATCH;
  2140.             break;
  2141.          }
  2142.          if (found && isub) {
  2143.             rval = MENU_AMBIGUOUS;
  2144.             break;
  2145.          }
  2146.          else {
  2147.             found = 1;
  2148.             *ptr_rval = rvals[j];
  2149.             rval = MENU_MATCH;
  2150.          }
  2151.       }
  2152.       else {
  2153.          continue;
  2154.       }
  2155.   }
  2156.  
  2157.   rtn :
  2158.   
  2159.   switch (rval) {
  2160.     case MENU_MATCH :
  2161.       break;
  2162.     case MENU_NO_MATCH :
  2163.       if (r_no_match) {
  2164.          printf("Your response does not match any option.  Try again\n");
  2165.          goto try_again;
  2166.       }
  2167.       break;
  2168.     case MENU_AMBIGUOUS :
  2169.       if (r_ambiguous) {
  2170.          printf("Your response is ambiguous.  Try again\n");
  2171.          goto try_again;
  2172.       }
  2173.       break;
  2174.     default :
  2175.       fprintf(stderr,"Impossible case value in menu_match\n");
  2176.       exit(-1);
  2177.   }
  2178.       
  2179.   return(rval);
  2180.   
  2181. }
  2182.  
  2183.  
  2184. menu_yes_no (prompt,allow_help) char *prompt; int allow_help;
  2185.  
  2186. {
  2187.   int menuval,rval;
  2188.   char *response;
  2189.   
  2190.   redo :
  2191.   
  2192.   if (!allow_help) {
  2193.      rval = menu_match (
  2194.           &menuval,&response,
  2195.           prompt,
  2196.           0,1,0,0,2,
  2197.           "Yes",MENU_YES,
  2198.           "No",MENU_NO
  2199.        );
  2200.   }
  2201.   else {
  2202.      rval = menu_match (
  2203.           &menuval,&response,
  2204.           prompt,
  2205.           0,1,0,0,4,
  2206.           "Yes",MENU_YES,
  2207.           "No",MENU_NO,
  2208.           "?",MENU_HELP,
  2209.           "Help",MENU_HELP
  2210.        );
  2211.   }
  2212.   switch (rval) {
  2213.     case MENU_MATCH :
  2214.       return(menuval);
  2215.       break;
  2216.     case MENU_NO_MATCH :
  2217.       fprintf(stderr,"Please type 'Yes' or 'No'...\n");
  2218.       goto redo;
  2219.       break;
  2220.     case MENU_EOF :
  2221.       return(MENU_EOF);
  2222.       break;
  2223.     default :
  2224.       fprintf(stderr,"Fatal error:  Impossible return in menu_yes_no\n");
  2225.       exit(-1);
  2226.   }
  2227. }
  2228.  
  2229.  
  2230. extern int menu_data_help_or_abort (prompt,abortstring,ptr_response)
  2231.  
  2232.   char *prompt, *abortstring, **ptr_response;
  2233.  
  2234. {
  2235.   int rval,menuval;
  2236.   rval = menu_match (
  2237.        &menuval,ptr_response,
  2238.        prompt,
  2239.        0,1,0,1,3,
  2240.        abortstring,MENU_ABORT,
  2241.        "?",MENU_HELP,
  2242.        "Help",MENU_HELP
  2243.     );
  2244.   switch (rval) {
  2245.     case MENU_NO_MATCH :
  2246.       return(MENU_DATA);
  2247.       break;
  2248.     case MENU_MATCH :
  2249.       return(menuval);
  2250.       break;
  2251.     case MENU_EOF :
  2252.       return(MENU_EOF);
  2253.       break;
  2254.     default :
  2255.       fprintf(stderr,"Impossible return from menu_data_help_or_abort\n");
  2256.       exit(-1);
  2257.   }
  2258. }
  2259.  
  2260.  
  2261. menu_number_help_or_abort (prompt,abortstring,low,high,ptr_ival)
  2262.  
  2263.   char *prompt, *abortstring;
  2264.   int low,high,*ptr_ival;
  2265.  
  2266. {
  2267.   char *response,errprompt[80],numstring[MAX_MENU_RESPONSE_LENGTH];
  2268.   int rval,check;
  2269.   
  2270.   if (!(check = (low <= high)))
  2271.      nbuffconcat(errprompt,1,"Please enter a non-negative number...\n");
  2272.   else
  2273.      sprintf(errprompt,"Please enter a number between %d and %d\n",low,high);
  2274.   
  2275.   reask :     
  2276.      
  2277.   rval = menu_data_help_or_abort(prompt,abortstring,&response);
  2278.   switch (rval) {
  2279.     case MENU_EOF :
  2280.     case MENU_ABORT :
  2281.     case MENU_HELP :
  2282.       return(rval);
  2283.       break;
  2284.     case MENU_DATA :
  2285.       remove_excess_blanks(numstring,response);
  2286.       switch (*ptr_ival = str_to_pos_int(numstring,0,MAXINT)) {
  2287.         case -1:
  2288.         case -2:
  2289.           fprintf(stderr,"%s",errprompt);
  2290.           goto reask;
  2291.           break;
  2292.         default:
  2293.           return(MENU_DATA);
  2294.           break;
  2295.       }
  2296.   }
  2297.  
  2298. }
  2299.  
  2300.  
  2301. menu_yes_no_abort_or_help (prompt,abortstring,helpallowed,return_for_yes)
  2302.  
  2303. /*
  2304.     Returns one of MENU_YES, MENU_NO, MENU_ABORT or MENU_HELP.
  2305.     If !helpallowed, MENU_HELP will not be returned.  
  2306.     If return_for_yes is 0, hitting return will re-prompt.
  2307.     If it is 1, hitting return is like typing yes.
  2308.     If it is any other value, hitting return is like typing no.
  2309. */
  2310.  
  2311.   char *prompt;
  2312.   char *abortstring;
  2313.   int helpallowed; 
  2314.   int return_for_yes;
  2315.  
  2316. {
  2317.   int menuval,rval;
  2318.   char *response;
  2319.   
  2320.   redo :
  2321.   
  2322.   if (!helpallowed) {
  2323.      rval = menu_match (
  2324.           &menuval,&response,
  2325.           prompt,
  2326.           0,1,0,0,4,
  2327.           "Yes",MENU_YES,
  2328.           "No",MENU_NO,
  2329.           abortstring,MENU_ABORT,
  2330.           "",MENU_RETURN
  2331.        );
  2332.   }
  2333.   else {
  2334.      rval = menu_match (
  2335.           &menuval,&response,
  2336.           prompt,
  2337.           0,1,0,0,6,
  2338.           "Yes",MENU_YES,
  2339.           "No",MENU_NO,
  2340.           "?",MENU_HELP,
  2341.           "Help",MENU_HELP,
  2342.           abortstring,MENU_ABORT,
  2343.           "",MENU_RETURN
  2344.        );
  2345.   }
  2346.   switch (rval) {
  2347.     case MENU_MATCH :
  2348.       if (menuval != MENU_RETURN) return(menuval);
  2349.       switch (return_for_yes) {
  2350.         case NO_DEFAULT :
  2351.           goto redo;
  2352.           break;
  2353.         case DEFAULT_YES :
  2354.           return(MENU_YES);
  2355.           break;
  2356.         default :
  2357.           return(MENU_NO);
  2358.           break;
  2359.       }
  2360.       break;
  2361.     case MENU_NO_MATCH :
  2362.       printf("Please type 'Yes' or 'No'...\n");
  2363.       goto redo;
  2364.       break;
  2365.     case MENU_EOF :
  2366.       return(MENU_EOF);
  2367.       break;
  2368.     default :
  2369.       fprintf(stderr,"Fatal error:  Impossible return in menu_yes_no\n");
  2370.       exit(-1);
  2371.   }
  2372. }
  2373.  
  2374. SHAR_EOF
  2375. if test 7644 -ne "`wc -c < 'toolsdir/menu.c'`"
  2376. then
  2377.     echo shar: error transmitting "'toolsdir/menu.c'" '(should have been 7644 characters)'
  2378. fi
  2379. fi
  2380. echo shar: extracting "'toolsdir/menu.h'" '(4423 characters)'
  2381. if test -f 'toolsdir/menu.h'
  2382. then
  2383.     echo shar: will not over-write existing file "'toolsdir/menu.h'"
  2384. else
  2385. cat << \SHAR_EOF > 'toolsdir/menu.h'
  2386. /* You must include "<ctools.h>" before including this file. */
  2387.  
  2388. #define MENU_EOF -1
  2389. #define MENU_MATCH 0
  2390. #define MENU_AMBIGUOUS 1
  2391. #define MENU_NO_MATCH 2        
  2392. #define MENU_ERROR 3
  2393. #define MENU_RETURN 4
  2394.  
  2395. #define MAX_MENU_OPTIONS 20
  2396. #define MAX_MENU_RESPONSE_LENGTH 255
  2397.  
  2398.  
  2399. extern int menu_match();
  2400.  
  2401. /* menu_match (
  2402.  
  2403.         int *ptr_rval,
  2404.         char **ptr_user_response,
  2405.         char *prompt,
  2406.         int case_significant,
  2407.         int initial_substring_sufficient,
  2408.         int repeat_if_no_match,
  2409.         int repeat_if_ambiguous,
  2410.         int n_options,
  2411.         char *option1, int rval1,
  2412.         char *option2, int rval2,
  2413.         .
  2414.         .
  2415.         .
  2416.  
  2417.     );
  2418.  
  2419.     Returns one of MENU_MATCH, MENU_AMBIGUOUS, MENU_NO_MATCH, and MENU_ERROR.
  2420.     If MENU_MATCH is returned, *ptr_rval contains the value that the caller
  2421.     asked to be returned.  *ptr_user_response is what exactly what the user
  2422.     typed in, minus the linefeed at the end.
  2423.     
  2424.     prompt is a character string that is printed out.  A line of input is
  2425.     then read from the terminal, stripped of excess blanks, and compared
  2426.     with the menu items.  Up to MAX_MENU_OPTIONS can be specified.  Each
  2427.     option is a character string and has an associated integer return value.
  2428.     
  2429.     If case_significant is not zero, the user's response will be checked
  2430.     against the options with upper/lower case distinction. 
  2431.     If initial_substring_sufficient is not zero, then a match will occur
  2432.     if the user's response is the same as an initial substring of an option,
  2433.     otherwise the response must match the option exactly.
  2434.     
  2435.     If more than one menu option matches the response, MENU_AMBIGUOUS is
  2436.     returned.  If n_options exceeds MAX_MENU_OPTIONS or the read fails
  2437.     MENU_ERROR is returned.  If no option matches the response, MENU_NO_MATCH
  2438.     is returned.  However, if repeat_if_no_match and/or repeat_if_ambiguous
  2439.     are non_zero, the user is prompted again until he answers correctly if
  2440.     he answers wrongly/ambiguously, respectively.
  2441.     
  2442.     If "" is not specified as an option, and the user enters a blank line,
  2443.     the routine simply prompts the user again.  It is impossible to match
  2444.     on a string of blanks (e.g., "  "), because any blank line the user
  2445.     types is considered to be "".
  2446.     
  2447.     If the response the user types is too long, an error message is printed
  2448.     out and the user is asked to try again.
  2449.     
  2450. */
  2451.  
  2452.  
  2453. #define MENU_NO 0
  2454. #define MENU_YES 1
  2455. #define MENU_HELP 2
  2456. #define MENU_ABORT 3
  2457. #define MENU_DATA 4
  2458.  
  2459. extern int menu_yes_no();
  2460.  
  2461. /* menu_yes_no (prompt,allow_help) char *prompt; int allow_help;
  2462.  
  2463.         returns one of MENU_NO, MENU_YES or, if help is allowed,
  2464.         MENU_HELP.  Help can be obtained via "?" or any initial
  2465.         substring of "Help", case independently.  Returns MENU_EOF
  2466.         if end of file encountered when reading. 
  2467.  
  2468.         Yes or no can be obtained via any case independent initial
  2469.         substring of "Yes" or "No" respectively.
  2470.  
  2471. */
  2472.  
  2473.  
  2474. #define DEFAULT_YES 0
  2475. #define DEFAULT_NO 1
  2476. #define NO_DEFAULT 2
  2477.  
  2478. extern int menu_yes_no_abort_or_help ();
  2479.  
  2480. /*  menu_yes_no_abort_or_help (prompt,abortstring,helpallowed,return_for_yes)
  2481.  
  2482.     char *prompt, *abortstring;
  2483.     int helpallowed; 
  2484.     int return_for_yes;
  2485.  
  2486.     Returns one of MENU_YES, MENU_NO, MENU_ABORT, MENU_HELP or MENU_EOF.
  2487.     If !helpallowed, MENU_HELP will not be returned.  
  2488.     If return_for_yes is DEFAULT_NO, hitting return will re-prompt.
  2489.     If it is DEFAULT_YES, hitting return is like typing yes.
  2490.     If it is any other value, hitting return is like typing no.
  2491.  
  2492. */    
  2493.  
  2494. extern int menu_data_help_or_abort ();
  2495.  
  2496. /*
  2497.  
  2498. extern int menu_data_help_or_abort (prompt,abortstring,ptr_response)
  2499.  
  2500.   char *prompt, *abortstring, **ptr_response;
  2501.  
  2502.   Returns either MENU_ABORT, MENU_HELP or MENU_DATA.  If MENU_DATA is
  2503.   returned, *response contains the user's response.  MENU_HELP is
  2504.   returned in the user types in "?" or any initial substring of "Help"
  2505.   (case independently).
  2506.   
  2507. */  
  2508.   
  2509.  
  2510. extern int menu_number_help_or_abort ();
  2511.  
  2512. /*
  2513. menu_number_help_or_abort (prompt,abortstring,low,high,ptr_ival)
  2514.  
  2515.   char *prompt; *abortstring;
  2516.   int low,high,*ptr_ival;
  2517.  
  2518.   Returns either MENU_DATA, MENU_ABORT, MENU_HELP or MENU_EOF.
  2519.   If low > high any number will be considered valid, otherwise the
  2520.   range is checked, inclusivewise.  If MENU_DATA is returned, *ptr_ival
  2521.   contains the number entered.
  2522.  
  2523.   At the moment number can only be non-negative.
  2524. */
  2525. SHAR_EOF
  2526. if test 4423 -ne "`wc -c < 'toolsdir/menu.h'`"
  2527. then
  2528.     echo shar: error transmitting "'toolsdir/menu.h'" '(should have been 4423 characters)'
  2529. fi
  2530. fi
  2531. echo shar: extracting "'toolsdir/sys5.h'" '(103 characters)'
  2532. if test -f 'toolsdir/sys5.h'
  2533. then
  2534.     echo shar: will not over-write existing file "'toolsdir/sys5.h'"
  2535. else
  2536. cat << \SHAR_EOF > 'toolsdir/sys5.h'
  2537. #ifdef SYS5
  2538. #define index(a,b) strchr(a,b)
  2539. #define rindex(a,b) strrchr(a,b)
  2540. #include <string.h>
  2541. #endif
  2542. SHAR_EOF
  2543. if test 103 -ne "`wc -c < 'toolsdir/sys5.h'`"
  2544. then
  2545.     echo shar: error transmitting "'toolsdir/sys5.h'" '(should have been 103 characters)'
  2546. fi
  2547. fi
  2548. echo shar: done with directory "'toolsdir'"
  2549. exit 0
  2550. #    End of shell archive
  2551.